using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;
using TxTReader.Core;
using TxTReader.Services;

namespace TxTReader.UI
{
    /// <summary>
    /// 基于TextBlock的文本控件
    /// 支持自动换行和滚动功能
    /// </summary>
    public class TextBlockTextControl : UserControl
    {
        #region 事件
        /// <summary>
        /// 滚动事件
        /// </summary>
        public event EventHandler? Scrolled;
        #endregion

        #region 私有字段
        private ScrollViewer _scrollViewer;
        private TextBox _textBox;
        private IFileReader? _fileReader;
        private Dictionary<int, string> _pageCache;
        private HashSet<int> _loadingPages;
        private int _currentPageNumber = 1;
        private int _totalFileLines = 0;
        private int _cacheSize = 1000; // 每页缓存行数
        private int _maxCachePages = 5; // 最大缓存页数（前2页+当前页+后3页）
        private int _preloadPagesBefore = 2; // 预加载前面页数
        private int _preloadPagesAfter = 3; // 预加载后面页数
        private bool _isLoading = false;
        private FontFamily _fontFamily = new FontFamily("Consolas");
        private double _fontSize = 12;
        private Brush _foregroundBrush = Brushes.Black;
        private Brush _backgroundBrush = Brushes.White;

        // 主题相关属性
        public new Brush Background
        {
            get => _backgroundBrush;
            set
            {
                _backgroundBrush = value;
                if (_textBox != null)
                {
                    _textBox.Background = value;
                }
            }
        }

        public new Brush Foreground
        {
            get => _foregroundBrush;
            set
            {
                _foregroundBrush = value;
                if (_textBox != null)
                {
                    _textBox.Foreground = value;
                }
            }
        }

        public new FontFamily FontFamily
        {
            get => _fontFamily;
            set
            {
                _fontFamily = value;
                if (_textBox != null)
                {
                    _textBox.FontFamily = value;
                }
            }
        }

        public new double FontSize
        {
            get => _fontSize;
            set
            {
                _fontSize = value;
                if (_textBox != null)
                {
                    _textBox.FontSize = value;
                }
            }
        }
        private bool _enableWordWrap = true;
        private int _maxCharsPerLine = 0; // 0表示不限制，根据窗口宽度自动换行
        private WordWrapMode _currentWordWrapMode = WordWrapMode.None;
        private int _currentWrapLength = 80;
        private bool _showLineNumbers = false;
        private StringBuilder _textBuilder = new StringBuilder();
        #endregion

        #region 构造函数
        public TextBlockTextControl()
        {
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            // 创建TextBox
            _textBox = new TextBox
            {
                FontFamily = _fontFamily,
                FontSize = _fontSize,
                Foreground = _foregroundBrush,
                Background = _backgroundBrush,
                TextWrapping = TextWrapping.Wrap, // 默认启用换行
                AcceptsReturn = false, // 禁用回车键处理
                AcceptsTab = false, // 禁用Tab键处理
                IsReadOnly = true, // 只读模式，提高性能
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled, // 默认禁用水平滚动条
                Padding = new Thickness(5),
                Margin = new Thickness(0),
                BorderThickness = new Thickness(0), // 无边框
                Focusable = false // 禁用焦点，让父窗口处理键盘事件
            };

            // 创建ScrollViewer
            _scrollViewer = new ScrollViewer
            {
                Content = _textBox,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled, // 默认禁用水平滚动条
                Background = _backgroundBrush,
                Padding = new Thickness(0),
                CanContentScroll = false, // 使用像素滚动，提高性能
                PanningMode = PanningMode.VerticalOnly, // 只允许垂直滚动
                IsDeferredScrollingEnabled = true // 启用延迟滚动，提高性能
            };

            // 绑定滚动事件
            _scrollViewer.ScrollChanged += OnScrollChanged;

            // 设置内容
            Content = _scrollViewer;

            // 初始化缓存
            _pageCache = new Dictionary<int, string>();
            _loadingPages = new HashSet<int>();

            // 监听滚动事件
            _scrollViewer.ScrollChanged += OnScrollChanged;
        }
        #endregion

        #region 公共方法
        public async Task SetFileReaderAsync(IFileReader fileReader)
        {
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetFileReaderAsync: 开始设置文件读取器");

            if (_isLoading)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetFileReaderAsync: 正在加载中，忽略此次调用");
                return;
            }

            // 清除内容并重置状态
            _currentPageNumber = 1;
            _totalFileLines = 0;
            _fileReader = fileReader;
            _textBox.Text = string.Empty;

            // 清除缓存
            _pageCache.Clear();
            _loadingPages.Clear();

            if (_fileReader != null && _fileReader.IsFileOpen)
            {
                _totalFileLines = (int)_fileReader.TotalLines;
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetFileReaderAsync: 文件总行数 {_totalFileLines}");

                // 载入第一页
                await LoadPageAsync(1);
            }
        }

        /// <summary>
        /// 向上滚动一行
        /// </summary>
        public void ScrollLineUp()
        {
            _scrollViewer?.LineUp();
        }

        /// <summary>
        /// 向下滚动一行
        /// </summary>
        public void ScrollLineDown()
        {
            _scrollViewer?.LineDown();
        }

        /// <summary>
        /// 向上翻一屏
        /// </summary>
        public void ScrollPageUp()
        {
            _scrollViewer?.PageUp();
        }

        /// <summary>
        /// 向下翻一屏
        /// </summary>
        public void ScrollPageDown()
        {
            _scrollViewer?.PageDown();
        }

        public void Clear()
        {
            _currentPageNumber = 1;
            _totalFileLines = 0;
            _fileReader = null;
            _textBox.Text = string.Empty;

            // 清除缓存
            _pageCache.Clear();
            _loadingPages.Clear();
        }

        public async Task LoadNextPageAsync()
        {
            if (_fileReader == null || _isLoading) return;

            var nextPageNumber = _currentPageNumber + 1;
            var maxPageNumber = GetMaxPageNumber();

            if (nextPageNumber > maxPageNumber) return;

            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadNextPageAsync: 载入第 {nextPageNumber} 页");

            // 如果页面已缓存，立即显示
            if (_pageCache.ContainsKey(nextPageNumber))
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadNextPageAsync: 从缓存加载第 {nextPageNumber} 页");
                LoadCachedPage(nextPageNumber, scrollToTop: true, resetScrollPosition: true, scrollToBottom: false);
                _currentPageNumber = nextPageNumber;
            }
            else
            {
                // 如果页面未缓存，异步加载
                await LoadPageAsync(nextPageNumber);
            }

            // 异步预加载相邻页面
            _ = PreloadAdjacentPagesAsync();
        }

        public async Task LoadPreviousPageAsync()
        {
            if (_fileReader == null || _isLoading) return;

            var previousPageNumber = _currentPageNumber - 1;

            if (previousPageNumber < 1) return;

            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPreviousPageAsync: 载入第 {previousPageNumber} 页");

            // 如果页面已缓存，立即显示
            if (_pageCache.ContainsKey(previousPageNumber))
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPreviousPageAsync: 从缓存加载第 {previousPageNumber} 页");
                LoadCachedPage(previousPageNumber, scrollToTop: false, resetScrollPosition: false, scrollToBottom: true);
                _currentPageNumber = previousPageNumber;
            }
            else
            {
                // 如果页面未缓存，异步加载
                await LoadPageAsync(previousPageNumber, scrollToTop: false, scrollToBottom: true);
            }

            // 异步预加载相邻页面
            _ = PreloadAdjacentPagesAsync();
        }

        public void UpdateFontSettings(FontFamily fontFamily, double fontSize, Brush foreground, Brush background)
        {
            _fontFamily = fontFamily;
            _fontSize = fontSize;
            _foregroundBrush = foreground;
            _backgroundBrush = background;

            // 应用字体设置
            _textBox.FontFamily = _fontFamily;
            _textBox.FontSize = _fontSize;
            _textBox.Foreground = _foregroundBrush;
            _textBox.Background = _backgroundBrush;
            _scrollViewer.Background = _backgroundBrush;
        }

        /// <summary>
        /// 设置缓存参数
        /// </summary>
        /// <param name="cacheSize">每页缓存行数</param>
        /// <param name="preloadPagesBefore">预加载前面页数</param>
        /// <param name="preloadPagesAfter">预加载后面页数</param>
        public void SetCacheSettings(int cacheSize, int preloadPagesBefore, int preloadPagesAfter)
        {
            _cacheSize = Math.Max(100, cacheSize); // 最少100行
            _preloadPagesBefore = Math.Max(0, preloadPagesBefore);
            _preloadPagesAfter = Math.Max(0, preloadPagesAfter);
            _maxCachePages = _preloadPagesBefore + 1 + _preloadPagesAfter; // 当前页 + 前后预加载页数

            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetCacheSettings: 缓存设置 - 每页{cacheSize}行, 前{preloadPagesBefore}页, 后{preloadPagesAfter}页, 最大缓存{_maxCachePages}页");
            
            // 清理现有缓存，强制重新加载
            _pageCache.Clear();
            _loadingPages.Clear();
            
            // 如果有文件打开，重新加载当前页
            if (_fileReader != null && _totalFileLines > 0)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetCacheSettings: 重新加载当前页 {_currentPageNumber}");
                _ = LoadPageAsync(_currentPageNumber);
            }
        }

        public string GetCurrentPageInfo()
        {
            if (_fileReader == null || _totalFileLines == 0)
                return "无文件";

            var maxPageNumber = GetMaxPageNumber();
            return $"{_currentPageNumber}/{maxPageNumber}";
        }

        public string GetCurrentDisplayRange()
        {
            if (_fileReader == null || _totalFileLines == 0)
                return "无内容";

            var startLine = (_currentPageNumber - 1) * _cacheSize + 1;
            var endLine = Math.Min(_totalFileLines, startLine + _cacheSize - 1);
            return $"第{startLine}-{endLine}行";
        }

        public string GetCacheInfo()
        {
            var cachedPages = _pageCache.Count;
            var loadingPages = _loadingPages.Count;
            return $"缓存: {cachedPages} 页, 加载中: {loadingPages} 页";
        }

        /// <summary>
        /// 获取当前查看的行号
        /// </summary>
        public int GetCurrentViewLine()
        {
            // 计算当前页面的起始行号
            var pageStartLine = (_currentPageNumber - 1) * _cacheSize + 1;
            
            // 如果有滚动视图，计算可视区域第一行的行号
            if (_scrollViewer != null && _scrollViewer.ScrollableHeight > 0)
            {
                // 计算滚动偏移量对应的行数
                var scrollOffset = _scrollViewer.VerticalOffset;
                var lineHeight = CalculateLineHeight();
                if (lineHeight > 0)
                {
                    var scrolledLines = (int)(scrollOffset / lineHeight);
                    return pageStartLine + scrolledLines;
                }
            }
            
            // 如果没有滚动信息，返回页面起始行号
            return pageStartLine;
        }

        public void SetWordWrapSettings(WordWrapMode wordWrapMode, int wrapLength)
        {
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetWordWrapSettings: 换行模式={wordWrapMode}, 长度={wrapLength}");
            
            // 保存当前设置
            _currentWordWrapMode = wordWrapMode;
            _currentWrapLength = wrapLength;
            _maxCharsPerLine = wrapLength; // 设置每行最大字符数
            
            // 应用设置
            ApplyCurrentWordWrapSettings();
        }

        /// <summary>
        /// 应用当前的换行设置
        /// </summary>
        private void ApplyCurrentWordWrapSettings()
        {
            System.Diagnostics.Debug.WriteLine($"ApplyCurrentWordWrapSettings: 当前换行模式 = {_currentWordWrapMode}");
            
            switch (_currentWordWrapMode)
            {
                case WordWrapMode.None:
                    _textBox.TextWrapping = TextWrapping.NoWrap;
                    _textBox.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
                    _scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
                    System.Diagnostics.Debug.WriteLine($"ApplyCurrentWordWrapSettings: 设置为不换行，显示水平滚动条");
                    break;
                case WordWrapMode.Window:
                    _textBox.TextWrapping = TextWrapping.Wrap;
                    _textBox.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    _scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    System.Diagnostics.Debug.WriteLine($"ApplyCurrentWordWrapSettings: 设置为按窗口换行，禁用水平滚动条");
                    break;
                case WordWrapMode.Character:
                    _textBox.TextWrapping = TextWrapping.NoWrap; // 禁用自动换行，使用手动换行
                    _textBox.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    _scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    System.Diagnostics.Debug.WriteLine($"ApplyCurrentWordWrapSettings: 设置为按字符数换行，禁用水平滚动条");
                    // 按字符数换行将在加载内容时处理
                    break;
            }
            
            // 强制刷新显示
            _textBox.InvalidateVisual();
            _textBox.UpdateLayout();
            
            System.Diagnostics.Debug.WriteLine($"ApplyCurrentWordWrapSettings: 设置完成 - TextBox.TextWrapping={_textBox.TextWrapping}, TextBox.HorizontalScrollBarVisibility={_textBox.HorizontalScrollBarVisibility}, ScrollViewer.HorizontalScrollBarVisibility={_scrollViewer.HorizontalScrollBarVisibility}");
        }

        /// <summary>
        /// 应用当前的字体设置
        /// </summary>
        private void ApplyFontSettings()
        {
            if (_textBox != null)
            {
                _textBox.FontFamily = _fontFamily;
                _textBox.FontSize = _fontSize;
                _textBox.Foreground = _foregroundBrush;
                _textBox.Background = _backgroundBrush;
                _scrollViewer.Background = _backgroundBrush;
            }
        }

        /// <summary>
        /// 按字符数换行处理文本（用于处理已缓存的文本，可能包含行号前缀）
        /// </summary>
        /// <param name="text">原始文本</param>
        /// <returns>处理后的文本</returns>
        private string ProcessTextWithCharacterWrap(string text)
        {
            if (_currentWordWrapMode != WordWrapMode.Character || _maxCharsPerLine <= 0)
            {
                return text;
            }

            var lines = text.Split('\n');
            var result = new StringBuilder();

            foreach (var line in lines)
            {
                if (string.IsNullOrEmpty(line))
                {
                    result.AppendLine();
                    continue;
                }

                // 检测是否包含行号前缀（格式：空格+数字+:空格）
                string contentLine;
                string prefix = string.Empty;
                
                if (_showLineNumbers && System.Text.RegularExpressions.Regex.IsMatch(line, @"^\s+\d+\s*:\s*"))
                {
                    // 包含行号前缀，提取前缀和内容
                    var match = System.Text.RegularExpressions.Regex.Match(line, @"^(\s+\d+\s*:\s*)(.*)$");
                    if (match.Success)
                    {
                        prefix = match.Groups[1].Value;
                        contentLine = match.Groups[2].Value;
                    }
                    else
                    {
                        // 可能是后续换行的行号前缀（格式：空格+:空格）
                        var match2 = System.Text.RegularExpressions.Regex.Match(line, @"^(\s+:\s*)(.*)$");
                        if (match2.Success)
                        {
                            prefix = match2.Groups[1].Value;
                            contentLine = match2.Groups[2].Value;
                        }
                        else
                        {
                            contentLine = line;
                        }
                    }
                }
                else
                {
                    contentLine = line;
                }

                if (string.IsNullOrEmpty(contentLine))
                {
                    result.AppendLine(prefix);
                    continue;
                }

                // 计算可用字符数（如果行号占用空间，需要减去行号前缀长度）
                int availableChars = _maxCharsPerLine;
                if (!string.IsNullOrEmpty(prefix))
                {
                    availableChars = _maxCharsPerLine;
                }

                // 按指定字符数分割行
                for (int i = 0; i < contentLine.Length; i += availableChars)
                {
                    var segment = contentLine.Substring(i, Math.Min(availableChars, contentLine.Length - i));
                    if (i == 0)
                    {
                        // 第一段使用原前缀
                        result.AppendLine(prefix + segment);
                    }
                    else
                    {
                        // 后续段使用空行号前缀（对齐用）
                        if (_showLineNumbers)
                        {
                            result.AppendLine($"      : {segment}");
                        }
                        else
                        {
                            result.AppendLine(segment);
                        }
                    }
                }
            }

            return result.ToString().TrimEnd('\r', '\n');
        }

        /// <summary>
        /// 按字符数将内容分割成多行（不包含行号前缀）
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="maxCharsPerLine">每行最大字符数</param>
        /// <returns>分割后的行列表</returns>
        private List<string> WrapContentByCharacters(string content, int maxCharsPerLine)
        {
            var result = new List<string>();
            
            if (string.IsNullOrEmpty(content))
            {
                result.Add(string.Empty);
                return result;
            }

            // 按指定字符数分割
            for (int i = 0; i < content.Length; i += maxCharsPerLine)
            {
                var segment = content.Substring(i, Math.Min(maxCharsPerLine, content.Length - i));
                result.Add(segment);
            }

            return result;
        }

        /// <summary>
        /// 设置行号显示
        /// </summary>
        /// <param name="showLineNumbers">是否显示行号</param>
        public void SetLineNumberSettings(bool showLineNumbers)
        {
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.SetLineNumberSettings: 显示行号={showLineNumbers}");
            
            _showLineNumbers = showLineNumbers;
            
            // 清除缓存，因为行号设置改变了内容格式
            _pageCache.Clear();
            
            // 如果当前有内容，重新加载以应用行号设置
            if (_currentPageNumber > 0)
            {
                LoadPageAsync(_currentPageNumber);
            }
        }
        #endregion

        #region 私有方法
        
        /// <summary>
        /// 滚动事件处理
        /// </summary>
        private void OnScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            // 触发滚动事件
            Scrolled?.Invoke(this, EventArgs.Empty);
        }
        
        /// <summary>
        /// 跳转到指定行，并将该位置置于可视区域的第一行
        /// </summary>
        /// <param name="targetLine">目标行号</param>
        public async Task JumpToLineAsync(int targetLine)
        {
            System.Diagnostics.Debug.WriteLine($"=== JumpToLineAsync 开始 ===");
            System.Diagnostics.Debug.WriteLine($"目标行号: {targetLine}");
            System.Diagnostics.Debug.WriteLine($"目标行号类型: {targetLine.GetType()}");
            System.Diagnostics.Debug.WriteLine($"目标行号值: {targetLine}");
            System.Diagnostics.Debug.WriteLine($"文件总行数: {_totalFileLines}");
            System.Diagnostics.Debug.WriteLine($"缓存大小: {_cacheSize}");
            System.Diagnostics.Debug.WriteLine($"当前页面: {_currentPageNumber}");
            System.Diagnostics.Debug.WriteLine($"是否正在加载: {_isLoading}");
            
            if (_fileReader == null)
            {
                System.Diagnostics.Debug.WriteLine("错误: _fileReader 为 null");
                return;
            }
            
            if (_isLoading)
            {
                System.Diagnostics.Debug.WriteLine("错误: 正在加载中，跳过此次跳转");
                return;
            }

            try
            {
                _isLoading = true;
                System.Diagnostics.Debug.WriteLine("设置 _isLoading = true");

                // 1. 直接根据目标行号计算目标页面
                var targetPage = (targetLine - 1) / _cacheSize + 1;
                var targetPageStartLine = (targetPage - 1) * _cacheSize + 1;
                var targetPageEndLine = Math.Min(_totalFileLines, targetPageStartLine + _cacheSize - 1);
                
                // 2. 计算目标行在目标页面中的相对位置（从0开始）
                var relativeLineInTargetPage = targetLine - targetPageStartLine;
                
                System.Diagnostics.Debug.WriteLine($"=== 详细页面计算调试信息 ===");
                System.Diagnostics.Debug.WriteLine($"目标行号: {targetLine}");
                System.Diagnostics.Debug.WriteLine($"每页行数 (_cacheSize): {_cacheSize}");
                System.Diagnostics.Debug.WriteLine($"(targetLine - 1) = {targetLine - 1}");
                System.Diagnostics.Debug.WriteLine($"(targetLine - 1) / _cacheSize = {(targetLine - 1) / _cacheSize}");
                System.Diagnostics.Debug.WriteLine($"targetPage = (targetLine - 1) / _cacheSize + 1 = {targetPage}");
                System.Diagnostics.Debug.WriteLine($"(targetPage - 1) = {targetPage - 1}");
                System.Diagnostics.Debug.WriteLine($"(targetPage - 1) * _cacheSize = {(targetPage - 1) * _cacheSize}");
                System.Diagnostics.Debug.WriteLine($"targetPageStartLine = (targetPage - 1) * _cacheSize + 1 = {targetPageStartLine}");
                System.Diagnostics.Debug.WriteLine($"relativeLineInTargetPage = targetLine - targetPageStartLine = {targetLine} - {targetPageStartLine} = {relativeLineInTargetPage}");
                System.Diagnostics.Debug.WriteLine($"=== 详细页面计算调试信息结束 ===");
                
                System.Diagnostics.Debug.WriteLine($"=== 页面计算调试信息 ===");
                System.Diagnostics.Debug.WriteLine($"目标行号: {targetLine}");
                System.Diagnostics.Debug.WriteLine($"每页行数 (_cacheSize): {_cacheSize}");
                System.Diagnostics.Debug.WriteLine($"文件总行数: {_totalFileLines}");
                System.Diagnostics.Debug.WriteLine($"当前页面号: {_currentPageNumber}");
                System.Diagnostics.Debug.WriteLine($"目标页面: {targetPage}");
                System.Diagnostics.Debug.WriteLine($"目标页面起始行: {targetPageStartLine}");
                System.Diagnostics.Debug.WriteLine($"目标页面结束行: {targetPageEndLine}");
                System.Diagnostics.Debug.WriteLine($"目标行在目标页面中的相对位置: {relativeLineInTargetPage}");
                System.Diagnostics.Debug.WriteLine($"=== 页面计算调试信息结束 ===");
                
                // 3. 判断目标行是否在当前页面
                var currentPageStartLine = (_currentPageNumber - 1) * _cacheSize + 1;
                var currentPageEndLine = Math.Min(_totalFileLines, currentPageStartLine + _cacheSize - 1);
                bool isInCurrentPage = targetLine >= currentPageStartLine && targetLine <= currentPageEndLine;
                System.Diagnostics.Debug.WriteLine($"是否在当前页面: {isInCurrentPage}");
                
                if (isInCurrentPage)
                {
                    // 2. 如果在当前页面，则直接跳转，将目标行置于可视区域第一行
                    var relativeLine = targetLine - currentPageStartLine;
                    System.Diagnostics.Debug.WriteLine($"在当前页面，相对行号: {relativeLine}");
                    
                    ScrollToLineInCurrentPage(relativeLine);
                    
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.JumpToLineAsync: 目标行 {targetLine} 在当前页面 {_currentPageNumber}，直接定位到相对行 {relativeLine}");
                }
                else
                {
                    // 4. 如果目标不在当前页面，加载目标页面并跳转
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.JumpToLineAsync: 目标行 {targetLine} 不在当前页面 {_currentPageNumber}，需要加载页面 {targetPage}");
                    
                    // 计算需要加载的页面范围（根据缓存设置）
                    var pagesToLoad = CalculatePagesToLoad(targetPage);
                    System.Diagnostics.Debug.WriteLine($"需要加载的页面: [{string.Join(",", pagesToLoad)}]");
                    
                    // 加载目标页面及其相邻页面
                    System.Diagnostics.Debug.WriteLine("开始加载页面范围...");
                    await LoadPageRangeAsync(pagesToLoad, targetPage);
                    System.Diagnostics.Debug.WriteLine("页面范围加载完成");
                    
                    // 等待布局完成
                    System.Diagnostics.Debug.WriteLine("等待布局完成...");
                    await Task.Delay(100); // 减少等待时间，避免过度延迟
                    await Dispatcher.InvokeAsync(() => { }, DispatcherPriority.Render);
                    System.Diagnostics.Debug.WriteLine("布局等待完成");
                    
                    // 使用预先计算好的相对位置进行滚动
                    System.Diagnostics.Debug.WriteLine($"=== 滚动前状态检查 ===");
                    System.Diagnostics.Debug.WriteLine($"目标页面: {targetPage}");
                    System.Diagnostics.Debug.WriteLine($"当前显示页面: {_currentPageNumber}");
                    System.Diagnostics.Debug.WriteLine($"目标行在目标页面中的相对位置: {relativeLineInTargetPage}");
                    System.Diagnostics.Debug.WriteLine($"目标行号: {targetLine}");
                    System.Diagnostics.Debug.WriteLine($"目标页面起始行: {targetPageStartLine}");
                    System.Diagnostics.Debug.WriteLine($"目标页面结束行: {targetPageEndLine}");
                    System.Diagnostics.Debug.WriteLine($"当前滚动位置: {_scrollViewer?.VerticalOffset ?? 0}");
                    System.Diagnostics.Debug.WriteLine($"每页行数: {_cacheSize}");
                    System.Diagnostics.Debug.WriteLine($"=== 滚动前状态检查结束 ===");
                    
                    // 滚动到目标行（将目标行置于可视区域的第一行）
                    System.Diagnostics.Debug.WriteLine("开始滚动到目标行...");
                    ScrollToLineInCurrentPage(relativeLineInTargetPage);
                    System.Diagnostics.Debug.WriteLine("滚动到目标行完成");
                    
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.JumpToLineAsync: 已加载页面范围 {string.Join(",", pagesToLoad)}，定位到相对行 {relativeLineInTargetPage}");
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.JumpToLineAsync Error: {ex.Message}");
                System.Diagnostics.Debug.WriteLine($"异常堆栈: {ex.StackTrace}");
            }
            finally
            {
                _isLoading = false;
                System.Diagnostics.Debug.WriteLine("设置 _isLoading = false");
                System.Diagnostics.Debug.WriteLine($"=== JumpToLineAsync 结束 ===");
            }
        }

        /// <summary>
        /// 计算需要加载的页面范围
        /// </summary>
        /// <param name="targetPage">目标页面</param>
        /// <returns>需要加载的页面列表</returns>
        private List<int> CalculatePagesToLoad(int targetPage)
        {
            var pagesToLoad = new List<int>();
            
            System.Diagnostics.Debug.WriteLine($"=== CalculatePagesToLoad 详细调试信息 ===");
            System.Diagnostics.Debug.WriteLine($"目标页面: {targetPage}");
            System.Diagnostics.Debug.WriteLine($"预加载前页数: {_preloadPagesBefore}");
            System.Diagnostics.Debug.WriteLine($"预加载后页数: {_preloadPagesAfter}");
            System.Diagnostics.Debug.WriteLine($"总页数: {GetTotalPages()}");
            System.Diagnostics.Debug.WriteLine($"当前缓存中的页面: {string.Join(",", _pageCache.Keys)}");
            
            // 计算页面范围
            var startPage = Math.Max(1, targetPage - _preloadPagesBefore);
            var endPage = Math.Min(GetTotalPages(), targetPage + _preloadPagesAfter);
            
            System.Diagnostics.Debug.WriteLine($"计算页面范围: {startPage} 到 {endPage}");
            
            // 添加需要加载的页面
            for (int page = startPage; page <= endPage; page++)
            {
                System.Diagnostics.Debug.WriteLine($"检查页面 {page}: 是否在缓存中 = {_pageCache.ContainsKey(page)}");
                if (!_pageCache.ContainsKey(page))
                {
                    pagesToLoad.Add(page);
                    System.Diagnostics.Debug.WriteLine($"页面 {page} 需要加载");
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine($"页面 {page} 已在缓存中，跳过");
                }
            }
            
            System.Diagnostics.Debug.WriteLine($"=== CalculatePagesToLoad 详细调试信息结束 ===");
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CalculatePagesToLoad: 目标页面 {targetPage}，需要加载的页面: {string.Join(",", pagesToLoad)}");
            return pagesToLoad;
        }

        /// <summary>
        /// 加载页面范围
        /// </summary>
        /// <param name="pagesToLoad">需要加载的页面列表</param>
        /// <param name="targetPage">目标页面</param>
        private async Task LoadPageRangeAsync(List<int> pagesToLoad, int targetPage)
        {
            System.Diagnostics.Debug.WriteLine($"=== LoadPageRangeAsync 开始 ===");
            System.Diagnostics.Debug.WriteLine($"目标页面: {targetPage}");
            System.Diagnostics.Debug.WriteLine($"需要加载的页面数量: {pagesToLoad.Count}");
            System.Diagnostics.Debug.WriteLine($"需要加载的页面: [{string.Join(",", pagesToLoad)}]");
            
            if (pagesToLoad.Count == 0) 
            {
                System.Diagnostics.Debug.WriteLine("没有需要加载的页面，检查目标页面是否在缓存中");
                
                // 即使没有需要加载的页面，也要确保目标页面被设置为当前显示页面
                if (_pageCache.ContainsKey(targetPage))
                {
                    System.Diagnostics.Debug.WriteLine($"目标页面 {targetPage} 已在缓存中，直接设置为当前显示页面");
                    LoadCachedPage(targetPage, scrollToTop: false, resetScrollPosition: false, scrollToBottom: false);
                    System.Diagnostics.Debug.WriteLine($"目标页面 {targetPage} 设置为当前显示页面完成");
                    System.Diagnostics.Debug.WriteLine($"设置后当前页面号: {_currentPageNumber}");
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine($"目标页面 {targetPage} 不在缓存中，需要加载");
                    await LoadPageDirectlyAsync(targetPage, false, true);
                    System.Diagnostics.Debug.WriteLine($"目标页面 {targetPage} 加载完成");
                    System.Diagnostics.Debug.WriteLine($"加载后当前页面号: {_currentPageNumber}");
                }
                
                System.Diagnostics.Debug.WriteLine("页面范围加载完成");
                return;
            }
            
            try
            {
                    // 优先加载目标页面
                if (pagesToLoad.Contains(targetPage))
                {
                    System.Diagnostics.Debug.WriteLine($"优先加载目标页面: {targetPage}");
                    
                    // 直接加载目标页面，更新显示内容
                    await LoadPageDirectlyAsync(targetPage, false, true);
                    System.Diagnostics.Debug.WriteLine($"目标页面 {targetPage} 加载完成");
                    System.Diagnostics.Debug.WriteLine($"加载后当前页面号: {_currentPageNumber}");
                    
                    // 等待UI完全渲染完成
                    System.Diagnostics.Debug.WriteLine("等待UI完全渲染完成...");
                    await Task.Delay(100); // 减少等待时间，避免过度延迟
                    await Dispatcher.InvokeAsync(() => { }, DispatcherPriority.Render);
                    System.Diagnostics.Debug.WriteLine("UI渲染等待完成");
                    
                    pagesToLoad.Remove(targetPage);
                    System.Diagnostics.Debug.WriteLine($"从待加载列表中移除目标页面，剩余页面: [{string.Join(",", pagesToLoad)}]");
                }
                
                // 并行加载其他页面（只加载到缓存，不更新显示）
                if (pagesToLoad.Count > 0)
                {
                    System.Diagnostics.Debug.WriteLine($"开始并行加载其他页面到缓存: [{string.Join(",", pagesToLoad)}]");
                    
                    var loadTasks = pagesToLoad.Select(page => LoadPageDirectlyAsync(page, false, false));
                    await Task.WhenAll(loadTasks);
                    System.Diagnostics.Debug.WriteLine("所有页面并行加载完成");
                }
                
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageRangeAsync: 已加载页面范围，目标页面 {targetPage}");
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"LoadPageRangeAsync Error: {ex.Message}");
                System.Diagnostics.Debug.WriteLine($"异常堆栈: {ex.StackTrace}");
                throw;
            }
            finally
            {
                System.Diagnostics.Debug.WriteLine($"=== LoadPageRangeAsync 结束 ===");
            }
        }

        /// <summary>
        /// 获取总页数
        /// </summary>
        /// <returns>总页数</returns>
        private int GetTotalPages()
        {
            return (int)Math.Ceiling((double)_totalFileLines / _cacheSize);
        }

        /// <summary>
        /// 计算字符宽度（近似值）
        /// </summary>
        /// <returns>字符宽度</returns>
        private double CalculateCharacterWidth()
        {
            try
            {
                // 使用FormattedText计算字符宽度
                var formattedText = new FormattedText(
                    "M", // 使用'M'作为参考字符
                    System.Globalization.CultureInfo.CurrentCulture,
                    FlowDirection.LeftToRight,
                    new Typeface(_fontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal),
                    _fontSize,
                    _foregroundBrush,
                    VisualTreeHelper.GetDpi(this).PixelsPerDip);

                return formattedText.Width;
            }
            catch
            {
                // 如果计算失败，返回默认值
                return _fontSize * 0.6; // 近似值
            }
        }

        /// <summary>
        /// 在当前页面中滚动到指定行（将目标行置于可视区域的第一行）
        /// </summary>
        /// <param name="relativeLine">在当前页面中的相对行号（从0开始）</param>
        private async void ScrollToLineInCurrentPage(int relativeLine)
        {
            System.Diagnostics.Debug.WriteLine($"=== ScrollToLineInCurrentPage 开始 ===");
            System.Diagnostics.Debug.WriteLine($"相对行号: {relativeLine}");
            
            try
            {
                // 等待UI完全渲染完成
                System.Diagnostics.Debug.WriteLine("等待UI完全渲染完成...");
                await Task.Delay(100);
                await Dispatcher.InvokeAsync(() => { }, DispatcherPriority.Render);
                System.Diagnostics.Debug.WriteLine("UI渲染等待完成");
                
                // 使用Dispatcher延迟滚动，确保布局完成
                await Dispatcher.InvokeAsync(() =>
                {
                    System.Diagnostics.Debug.WriteLine("Dispatcher.InvokeAsync 回调开始执行");
                    
                    // 计算行高
                    var lineHeight = CalculateLineHeight();
                    System.Diagnostics.Debug.WriteLine($"计算得到的行高: {lineHeight}");
                    
                    if (lineHeight <= 0) 
                    {
                        System.Diagnostics.Debug.WriteLine("行高无效，退出滚动");
                        return;
                    }
                    
                    // 计算目标行的垂直偏移量
                    var targetOffset = relativeLine * lineHeight;
                    System.Diagnostics.Debug.WriteLine($"=== 滚动计算调试信息 ===");
                    System.Diagnostics.Debug.WriteLine($"相对行号: {relativeLine}");
                    System.Diagnostics.Debug.WriteLine($"计算得到的行高: {lineHeight}");
                    System.Diagnostics.Debug.WriteLine($"计算目标偏移量: {targetOffset}");
                    System.Diagnostics.Debug.WriteLine($"=== 滚动计算调试信息结束 ===");
                    
                    // 检查ScrollViewer状态
                    if (_scrollViewer == null)
                    {
                        System.Diagnostics.Debug.WriteLine("错误: _scrollViewer 为 null");
                        return;
                    }
                    
                    System.Diagnostics.Debug.WriteLine($"ScrollViewer 当前垂直偏移: {_scrollViewer.VerticalOffset}");
                    System.Diagnostics.Debug.WriteLine($"ScrollViewer 可滚动高度: {_scrollViewer.ScrollableHeight}");
                    
                    // 滚动到目标位置
                    _scrollViewer.ScrollToVerticalOffset(targetOffset);
                    
                    System.Diagnostics.Debug.WriteLine($"滚动完成，新的垂直偏移: {_scrollViewer.VerticalOffset}");
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ScrollToLineInCurrentPage: 滚动到相对行 {relativeLine}，偏移量 {targetOffset}，行高 {lineHeight}");
                }, DispatcherPriority.Render);
                
                System.Diagnostics.Debug.WriteLine("Dispatcher.InvokeAsync 调用完成");
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ScrollToLineInCurrentPage Error: {ex.Message}");
                System.Diagnostics.Debug.WriteLine($"异常堆栈: {ex.StackTrace}");
            }
            finally
            {
                System.Diagnostics.Debug.WriteLine($"=== ScrollToLineInCurrentPage 结束 ===");
            }
        }

        /// <summary>
        /// 直接加载页面，不检查 _isLoading 状态（用于跨页面跳转）
        /// </summary>
        private async Task LoadPageDirectlyAsync(int pageNumber, bool scrollToTop = true, bool updateDisplay = true)
        {
            if (_fileReader == null) return;

            try
            {
                // 检查缓存
                if (_pageCache.ContainsKey(pageNumber))
                {
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageDirectlyAsync: 从缓存载入第 {pageNumber} 页");
                    if (updateDisplay)
                    {
                        _currentPageNumber = pageNumber;
                        LoadCachedPage(pageNumber, scrollToTop, resetScrollPosition: true, scrollToBottom: false);
                    }
                    
                    // 等待布局完成
                    await Task.Delay(50);
                    return;
                }

                // 计算页的范围
                var startLine = (pageNumber - 1) * _cacheSize + 1;
                var endLine = Math.Min(_totalFileLines, startLine + _cacheSize - 1);

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageDirectlyAsync: 载入第 {pageNumber} 页 ({startLine}-{endLine})");

                // 使用批量读取方法，一次性读取所有行
                var lines = await _fileReader.GetLinesAsync(startLine, endLine - startLine + 1);

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageDirectlyAsync: 读取到 {lines.Count} 行");

                // 使用StringBuilder高效构建文本内容
                _textBuilder.Clear();
                
                // 如果启用按字符数换行，需要先处理内容再添加行号
                if (_currentWordWrapMode == WordWrapMode.Character && _maxCharsPerLine > 0)
                {
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        var content = lines[i].Content;
                        
                        // 先对原始内容按字符数换行
                        var wrappedLines = WrapContentByCharacters(content, _maxCharsPerLine);
                        
                        // 为每一行添加行号前缀（第一行使用实际行号，后续行使用空前缀或特殊标记）
                        for (int j = 0; j < wrappedLines.Count; j++)
                        {
                            if (_showLineNumbers)
                            {
                                // 第一行显示行号，后续换行行不显示行号，用空格填充以对齐
                                if (j == 0)
                                {
                                    _textBuilder.AppendLine($"{lineNumber,6}: {wrappedLines[j]}");
                                }
                                else
                                {
                                    _textBuilder.AppendLine($"      : {wrappedLines[j]}");
                                }
                            }
                            else
                            {
                                _textBuilder.AppendLine(wrappedLines[j]);
                            }
                        }
                    }
                }
                else
                {
                    // 普通模式：直接添加行号或内容
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        if (_showLineNumbers)
                        {
                            _textBuilder.AppendLine($"{lineNumber,6}: {lines[i].Content}");
                        }
                        else
                        {
                            _textBuilder.AppendLine(lines[i].Content);
                        }
                    }
                }

                var pageContent = _textBuilder.ToString();

                // 缓存当前页
                _pageCache[pageNumber] = pageContent;

                // 只有在需要更新显示时才更新状态和显示内容
                if (updateDisplay)
                {
                    _currentPageNumber = pageNumber;
                    LoadCachedPage(pageNumber, scrollToTop);
                }

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageDirectlyAsync: 载入完成，共 {lines.Count} 行，更新显示: {updateDisplay}");

                // 等待布局完成
                await Task.Delay(50);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageDirectlyAsync Error: {ex.Message}");
            }
        }

        /// <summary>
        /// 重新加载当前页面
        /// </summary>
        public async Task ReloadCurrentPageAsync()
        {
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ReloadCurrentPageAsync: 重新加载第 {_currentPageNumber} 页");
            
            if (_fileReader == null || _isLoading)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ReloadCurrentPageAsync: 跳过重新加载，_fileReader = {_fileReader != null}, _isLoading = {_isLoading}");
                return;
            }

            // 清除当前页面的缓存，强制重新加载
            if (_pageCache.ContainsKey(_currentPageNumber))
            {
                _pageCache.Remove(_currentPageNumber);
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ReloadCurrentPageAsync: 清除第 {_currentPageNumber} 页缓存");
            }

            // 重新加载当前页面
            await LoadPageAsync(_currentPageNumber, false, false);
            
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.ReloadCurrentPageAsync: 第 {_currentPageNumber} 页重新加载完成");
        }

        public async Task LoadPageAsync(int pageNumber, bool scrollToTop = true, bool scrollToBottom = false)
        {
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 开始载入第 {pageNumber} 页");
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: _fileReader = {_fileReader != null}, _isLoading = {_isLoading}");
            
            if (_fileReader == null || _isLoading) 
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 跳过载入，_fileReader = {_fileReader != null}, _isLoading = {_isLoading}");
                return;
            }

            try
            {
                _isLoading = true;
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 设置 _isLoading = true");

                // 检查缓存
                if (_pageCache.ContainsKey(pageNumber))
                {
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 从缓存载入第 {pageNumber} 页");
                    _currentPageNumber = pageNumber;
                    LoadCachedPage(pageNumber, scrollToTop, resetScrollPosition: true, scrollToBottom);
                    
                    // 等待布局完成
                    await Task.Delay(50);
                    _isLoading = false; // 确保重置加载状态
                    System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 从缓存载入完成");
                    return;
                }

                // 计算页的范围
                var startLine = (pageNumber - 1) * _cacheSize + 1;
                var endLine = Math.Min(_totalFileLines, startLine + _cacheSize - 1);

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 载入第 {pageNumber} 页 ({startLine}-{endLine})");
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: _cacheSize = {_cacheSize}, _totalFileLines = {_totalFileLines}");

                // 使用批量读取方法，一次性读取所有行
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 开始调用 GetLinesAsync");
                var lines = await _fileReader.GetLinesAsync(startLine, endLine - startLine + 1);
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: GetLinesAsync 调用完成");

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 读取到 {lines.Count} 行");

                // 使用StringBuilder高效构建文本内容
                _textBuilder.Clear();
                
                // 如果启用按字符数换行，需要先处理内容再添加行号
                if (_currentWordWrapMode == WordWrapMode.Character && _maxCharsPerLine > 0)
                {
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        var content = lines[i].Content;
                        
                        // 先对原始内容按字符数换行
                        var wrappedLines = WrapContentByCharacters(content, _maxCharsPerLine);
                        
                        // 为每一行添加行号前缀（第一行使用实际行号，后续行使用空前缀或特殊标记）
                        for (int j = 0; j < wrappedLines.Count; j++)
                        {
                            if (_showLineNumbers)
                            {
                                // 第一行显示行号，后续换行行不显示行号，用空格填充以对齐
                                if (j == 0)
                                {
                                    _textBuilder.AppendLine($"{lineNumber,6}: {wrappedLines[j]}");
                                }
                                else
                                {
                                    _textBuilder.AppendLine($"      : {wrappedLines[j]}");
                                }
                            }
                            else
                            {
                                _textBuilder.AppendLine(wrappedLines[j]);
                            }
                        }
                    }
                }
                else
                {
                    // 普通模式：直接添加行号或内容
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        if (_showLineNumbers)
                        {
                            _textBuilder.AppendLine($"{lineNumber,6}: {lines[i].Content}");
                        }
                        else
                        {
                            _textBuilder.AppendLine(lines[i].Content);
                        }
                    }
                }

                var pageContent = _textBuilder.ToString();

                // 缓存当前页
                _pageCache[pageNumber] = pageContent;

                // 更新状态
                _currentPageNumber = pageNumber;
                LoadCachedPage(pageNumber, scrollToTop, resetScrollPosition: true, scrollToBottom);

                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadPageAsync: 载入完成，共 {lines.Count} 行");

                // 等待布局完成
                await Task.Delay(50);

                // 异步预加载相邻页面
                _ = PreloadAdjacentPagesAsync();
            }
            finally
            {
                _isLoading = false;
            }
        }

        private void LoadCachedPage(int pageNumber, bool scrollToTop = true, bool resetScrollPosition = true, bool scrollToBottom = false)
        {
            if (!_pageCache.ContainsKey(pageNumber))
            {
                System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 缓存中不存在第 {pageNumber} 页");
                return;
            }

            var cachedContent = _pageCache[pageNumber];
            System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 缓存内容长度 = {cachedContent.Length}");
            System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 缓存内容前100字符 = {cachedContent.Substring(0, Math.Min(100, cachedContent.Length))}");
            
            // 如果缓存中已经是处理过的文本（按字符数换行已经在构建缓存时处理），直接使用
            // 否则需要再次处理（这种情况应该不会发生，但保留作为备用）
            var processedContent = cachedContent;
            if (_currentWordWrapMode != WordWrapMode.Character || _maxCharsPerLine <= 0)
            {
                // 非按字符数换行模式，直接使用缓存内容
                processedContent = cachedContent;
            }
            // 按字符数换行的文本已经在构建缓存时处理过，不需要再次处理
            _textBox.Text = processedContent;
            System.Diagnostics.Debug.WriteLine($"LoadCachedPage: TextBox.Text 设置完成，长度 = {_textBox.Text.Length}");

            // 重新应用换行设置和字体设置（因为设置Text可能会重置属性）
            ApplyCurrentWordWrapSettings();
            ApplyFontSettings();

            // 根据参数决定滚动位置
            if (scrollToBottom)
            {
                // 滚动到底部（100%位置）
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    _scrollViewer.ScrollToBottom();
                    System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 滚动到底部（100%位置）");
                }), DispatcherPriority.Loaded);
            }
            else if (scrollToTop)
            {
                // 滚动到顶部（0%位置）
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    _scrollViewer.ScrollToTop();
                    System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 滚动到顶部（0%位置）");
                }), DispatcherPriority.Loaded);
            }
            else if (resetScrollPosition)
            {
                // 如果不需要滚动到顶部或底部，但需要重置滚动位置，确保滚动位置保持为0（页面顶部）
                // 这样后续的精确滚动计算会更准确
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    _scrollViewer.ScrollToVerticalOffset(0);
                    System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 重置滚动位置到0，为后续精确滚动做准备");
                }), DispatcherPriority.Render);
            }
            else
            {
                System.Diagnostics.Debug.WriteLine($"LoadCachedPage: 不重置滚动位置，保持当前滚动状态");
            }

            _currentPageNumber = pageNumber;
            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.LoadCachedPage: 显示第 {pageNumber} 页，滚动到顶部: {scrollToTop}，滚动到底部: {scrollToBottom}，重置滚动位置: {resetScrollPosition}");
        }

        private async Task PreloadAdjacentPagesAsync()
        {
            if (_fileReader == null) return;

            var tasks = new List<Task>();
            int maxPageNumber = GetMaxPageNumber();

            // 预加载指定数量的页面
            for (int offset = 1; offset <= _preloadPagesAfter; offset++)
            {
                // 预加载后面的页面
                var nextPageNumber = _currentPageNumber + offset;
                if (nextPageNumber <= maxPageNumber && 
                    !_pageCache.ContainsKey(nextPageNumber) && 
                    !_loadingPages.Contains(nextPageNumber))
                {
                    _loadingPages.Add(nextPageNumber);
                    tasks.Add(PreloadPageAsync(nextPageNumber));
                }
            }

            for (int offset = 1; offset <= _preloadPagesBefore; offset++)
            {
                // 预加载前面的页面
                var previousPageNumber = _currentPageNumber - offset;
                if (previousPageNumber >= 1 && 
                    !_pageCache.ContainsKey(previousPageNumber) && 
                    !_loadingPages.Contains(previousPageNumber))
                {
                    _loadingPages.Add(previousPageNumber);
                    tasks.Add(PreloadPageAsync(previousPageNumber));
                }
            }

            if (tasks.Count > 0)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.PreloadAdjacentPagesAsync: 开始预加载 {tasks.Count} 页");
                await Task.WhenAll(tasks);
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.PreloadAdjacentPagesAsync: 预加载完成");
            }

            // 清理超出范围的缓存
            CleanupCache();
        }

        /// <summary>
        /// 清理超出缓存范围的页面
        /// </summary>
        private void CleanupCache()
        {
            if (_pageCache.Count <= _maxCachePages) return;

            var pagesToRemove = new List<int>();
            var currentPage = _currentPageNumber;
            var minPage = Math.Max(1, currentPage - _preloadPagesBefore);
            var maxPage = Math.Min(GetMaxPageNumber(), currentPage + _preloadPagesAfter);

            // 找出超出缓存范围的页面
            foreach (var pageNumber in _pageCache.Keys)
            {
                if (pageNumber < minPage || pageNumber > maxPage)
                {
                    pagesToRemove.Add(pageNumber);
                }
            }

            // 移除超出范围的页面
            foreach (var pageNumber in pagesToRemove)
            {
                _pageCache.Remove(pageNumber);
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CleanupCache: 清理第 {pageNumber} 页缓存");
            }

            if (pagesToRemove.Count > 0)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CleanupCache: 清理了 {pagesToRemove.Count} 页缓存，当前缓存 {_pageCache.Count} 页");
            }
        }

        /// <summary>
        /// 获取当前页面号
        /// </summary>
        /// <returns>当前页面号</returns>
        public int GetCurrentPageNumber()
        {
            return _currentPageNumber;
        }

        /// <summary>
        /// 获取缓存大小（每页行数）
        /// </summary>
        /// <returns>缓存大小</returns>
        public int GetCacheSize()
        {
            return _cacheSize;
        }

        /// <summary>
        /// 获取文件总行数
        /// </summary>
        /// <returns>文件总行数</returns>
        public int GetTotalFileLines()
        {
            return _totalFileLines;
        }

        private async Task PreloadPageAsync(int pageNumber)
        {
            try
            {
                var startLine = (pageNumber - 1) * _cacheSize + 1;
                var endLine = Math.Min(_totalFileLines, startLine + _cacheSize - 1);

                var lines = await _fileReader!.GetLinesAsync(startLine, endLine - startLine + 1);

                // 使用StringBuilder高效构建文本内容
                _textBuilder.Clear();
                
                // 如果启用按字符数换行，需要先处理内容再添加行号
                if (_currentWordWrapMode == WordWrapMode.Character && _maxCharsPerLine > 0)
                {
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        var content = lines[i].Content;
                        
                        // 先对原始内容按字符数换行
                        var wrappedLines = WrapContentByCharacters(content, _maxCharsPerLine);
                        
                        // 为每一行添加行号前缀（第一行使用实际行号，后续行使用空前缀或特殊标记）
                        for (int j = 0; j < wrappedLines.Count; j++)
                        {
                            if (_showLineNumbers)
                            {
                                // 第一行显示行号，后续换行行不显示行号，用空格填充以对齐
                                if (j == 0)
                                {
                                    _textBuilder.AppendLine($"{lineNumber,6}: {wrappedLines[j]}");
                                }
                                else
                                {
                                    _textBuilder.AppendLine($"      : {wrappedLines[j]}");
                                }
                            }
                            else
                            {
                                _textBuilder.AppendLine(wrappedLines[j]);
                            }
                        }
                    }
                }
                else
                {
                    // 普通模式：直接添加行号或内容
                    for (int i = 0; i < lines.Count; i++)
                    {
                        var lineNumber = startLine + i;
                        if (_showLineNumbers)
                        {
                            _textBuilder.AppendLine($"{lineNumber,6}: {lines[i].Content}");
                        }
                        else
                        {
                            _textBuilder.AppendLine(lines[i].Content);
                        }
                    }
                }

                var pageContent = _textBuilder.ToString();
                _pageCache[pageNumber] = pageContent;
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.PreloadPageAsync: 预加载第 {pageNumber} 页完成");
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.PreloadPageAsync: 预加载第 {pageNumber} 页失败: {ex.Message}");
            }
            finally
            {
                _loadingPages.Remove(pageNumber);
            }
        }

        private int GetMaxPageNumber()
        {
            if (_totalFileLines == 0) return 1;
            return (int)Math.Ceiling((double)_totalFileLines / _cacheSize);
        }

        public int GetVisibleLinesPerScreen()
        {
            try
            {
                if (_textBox == null) return 48;
                
                // 计算可见行数
                var availableHeight = GetAvailableHeight();
                var lineHeight = CalculateLineHeight();
                
                if (lineHeight > 0)
                {
                    var visibleLines = (int)(availableHeight / lineHeight);
                    return Math.Max(1, visibleLines);
                }
                
                return 48; // 默认值
            }
            catch
            {
                return 48; // 默认值
            }
        }

        private double GetAvailableHeight()
        {
            try
            {
                if (_textBox?.Parent is ScrollViewer scrollViewer)
                {
                    return scrollViewer.ViewportHeight;
                }
                return _textBox?.ActualHeight ?? 400;
            }
            catch
            {
                return 400;
            }
        }

        private double CalculateLineHeight()
        {
            try
            {
                if (_textBox == null) return 16;
                
                System.Diagnostics.Debug.WriteLine($"=== CalculateLineHeight 调试信息 ===");
                System.Diagnostics.Debug.WriteLine($"TextBox.LineCount: {_textBox.LineCount}");
                System.Diagnostics.Debug.WriteLine($"TextBox.ExtentHeight: {_textBox.ExtentHeight}");
                System.Diagnostics.Debug.WriteLine($"TextBox.ActualHeight: {_textBox.ActualHeight}");
                System.Diagnostics.Debug.WriteLine($"TextBox.FontSize: {_textBox.FontSize}");
                
                // 方法1：尝试从TextBox获取实际行高
                if (_textBox.LineCount > 0)
                {
                    var textHeight = _textBox.ExtentHeight;
                    var lineCount = _textBox.LineCount;
                    if (lineCount > 0)
                    {
                        var calculatedHeight = textHeight / lineCount;
                        System.Diagnostics.Debug.WriteLine($"从TextBox计算: textHeight={textHeight}, lineCount={lineCount}, calculatedHeight={calculatedHeight}");
                        if (calculatedHeight > 0)
                        {
                            System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CalculateLineHeight: 从TextBox计算行高 {calculatedHeight}");
                            System.Diagnostics.Debug.WriteLine($"=== CalculateLineHeight 调试信息结束 ===");
                            return calculatedHeight;
                        }
                    }
                }
                
                // 方法2：使用FormattedText计算行高
                var formattedText = new FormattedText(
                    "测试文本",
                    System.Globalization.CultureInfo.CurrentCulture,
                    FlowDirection.LeftToRight,
                    new Typeface(_textBox.FontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal),
                    _textBox.FontSize,
                    _textBox.Foreground as SolidColorBrush ?? Brushes.Black,
                    VisualTreeHelper.GetDpi(this).PixelsPerDip);
                
                var formattedHeight = formattedText.Height;
                System.Diagnostics.Debug.WriteLine($"从FormattedText计算: formattedHeight={formattedHeight}");
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CalculateLineHeight: 从FormattedText计算行高 {formattedHeight}");
                System.Diagnostics.Debug.WriteLine($"=== CalculateLineHeight 调试信息结束 ===");
                return formattedHeight;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"TextBlockTextControl.CalculateLineHeight Error: {ex.Message}");
                // 如果计算失败，返回默认值
                return _fontSize * 1.2; // 更合理的默认值
            }
        }

        #endregion
    }
}
